
/**
 * 
 * 增强的strstr
 * 
 * 题目描述

C 语言有一个库函数： char *strstr(const char *haystack, const char *needle) ，实现在字符串 haystack 中查找第一次出现字符串 needle 的位置，如果未找到则返回 null。

现要求实现一个strstr的增强函数，可以使用带可选段的字符串来模糊查询，与strstr一样返回首次查找到的字符串位置。

可选段使用“[]”标识，表示该位置是可选段中任意一个字符即可满足匹配条件。比如“a[bc]”表示可以匹配“ab”或“ac”。

注意目标字符串中可选段可能出现多次。

输入描述
与strstr函数一样，输入参数是两个字符串指针，分别是源字符串和目标字符串。

输出描述
与strstr函数不同，返回的是源字符串中，匹配子字符串相对于源字符串地址的偏移（从0开始算），如果没有匹配返回-1。

补充说明：源字符串中必定不包含‘[]’；目标字符串中‘[]’必定成对出现，且不会出现嵌套。

输入的字符串长度在[1,100]之间。

用例
输入	abcd
b[cd]
输出	1
说明	相当于是在源字符串中查找bc或者bd，bc子字符串相对于abcd的偏移是1
 * 
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
  * 

  题目解析

  将目标串分层，比如目标串 b[cd]，相当于两层：

第一层可选字符是：b
第二层可选字符是：cd
然后利用滑窗，滑窗长度就是目标串的层数，去在源字符串中滑动匹配，比如

  */
public class 增强的strstr {
    
    public static void main(String[] args) {
        
        try{

            Scanner scanner = new Scanner(System.in);

            String originStr = scanner.nextLine();
            String targetStr = scanner.nextLine();

            //先遍历出[]中的内容

            if(!targetStr.contains("[")){

                if(originStr.contains(targetStr)){

                    System.out.println(originStr.indexOf(targetStr));

                }else{

                    //不存在 目标字符串
                    System.out.println("-1");

                }

            } else {
            
                // 将tar字符串转化为levels多层结构，转化逻辑为：tar字符串中，每个[]包含的所有字符作为一层，未被[]包含的单个字符作为一层
                ArrayList<HashSet<Character>> levels = new ArrayList<>();
                // level用于记录[]中的字符
                HashSet<Character> level = new HashSet<>();
 
                boolean isOpen = false;
                for (int i = 0; i < targetStr.length(); i++) {
                    char c = targetStr.charAt(i);
 
                    if (c == '[') {
                        isOpen = true;
                    } else if (c == ']') {
                        isOpen = false;
                        levels.add(level);
                        level = new HashSet<>();
                    } else if (isOpen) {
                        level.add(c);
                    } else {
                        HashSet<Character> tmp = new HashSet<>();
                        tmp.add(c);
                        levels.add(tmp);
                    }
                }
 
                System.out.println(indexOf(originStr, levels));

            }


        }catch(Exception e){

            e.printStackTrace();
        }
    }

    public static int indexOf(String src, ArrayList<HashSet<Character>> levels) {
        // 滑动匹配levels.length长度的子串
        for (int i = 0; i <= src.length() - levels.size(); i++) {
            int j = 0;
            for (; j < levels.size(); j++) {
                if (!levels.get(j).contains(src.charAt(i + j))) {
                    break;
                }
            }
 
            if (j == levels.size()) {
                return i;
            }
        }
 
        return -1;
    }
}
